package com.chenziwen.scala.exercises.chapter3

import java.util

import scala.collection.immutable
import scala.collection.mutable._

object Scala3 {
  def main(args: Array[String]): Unit = {
    // 1、编写一段代码，将a设置为一个n个随机整数的数组，要求随机数介于0和n之间。

    def rangeArray(n: Int): Array[Int] = {
      val a = new Array[Int](n)
      val random = new scala.util.Random()
      for (i <- a) yield random.nextInt(n)
    }

    println(rangeArray(10).toBuffer)

    // 2. 编写一个循环，将整数数组中相邻的元素置换。比如Array(1, 2, 3, 4, 5)置换后为Array(2, 1, 4, 3, 5)

    def exchange(arr: Array[Int]) = {
      for (i <- 0 until(arr.length - 1, 2)) {
        val t = arr(i)
        arr(i) = arr(i + 1)
        arr(i + 1) = t
      }
      arr
    }

    println(exchange(Array(1, 2, 3, 4, 5, 6)).toBuffer)


    // 3. 给定一个整数数组，产出一个新的数组，包含原数组中的所有正值，以原有顺序排列，之后的元素是所有零或负值，以原有顺序排列。

    val arr1 = Array(0, 2, -3, 4, -5, 6)
    val arr2 = arr1.collect { case x if x > 0 => x }
    val arr3 = arr1.collect { case x if x <= 0 => x }
    val arr4 = arr2 ++ arr3
    println(arr4.toBuffer)

    // 4. 创建一个由java.util.TimeZone.getAvailableIDs返回的时区集合，并只显示以America/前缀开头的时区，并且有序。

    def timeZoneName() = {
      val arr = java.util.TimeZone.getAvailableIDs
      val tmp = (for (i <- arr if i.startsWith("America/")) yield {
        i.drop("America/".length)
      })
      scala.util.Sorting.quickSort(tmp)
      tmp
    }

    timeZoneName().foreach(println)

    // 5、设置一个映射，其中包含你想要的一些装备，以及它们的价格。然后根据这个映射构建另一个新映射，采用同一组键，但是价格上打9折。

    val map = Map("98K" -> 100.0, "M32" -> 90.0, "AK" -> 80.0)

    val newMap = for ((k, v) <- map) yield (k, v * 0.9)

    println(newMap)

    // 6、编写一段WordCount函数，统计传入的字符串中单词的个数

    val str = "kh men abcd abcd efg"

    def wordCount(str: String) = {
      val count = new HashMap[String, Int]
      for (word <- str.split("\\s+"))
        count(word) = count.getOrElse(word, 0) + 1
      count
    }

    println(wordCount(str))

    // 7、重复上一个练习，使统计后的单词有序

    def wordCountSort(str: String) = {
      var count = immutable.SortedMap[String, Int]()
      for (word <- str.split("\\s+"))
        count += (word -> (count.getOrElse(word, 0) + 1))
      count
    }

    println(wordCountSort(str))

    // 8、 重复前一个练习，使用java.util.TreeMap进行实现，并使之适用于Scala API
    import scala.collection.JavaConversions.mapAsScalaMap
    def wordCountTreeMap(str: String) = {
      var count: scala.collection.mutable.Map[String, Int] = new util.TreeMap[String, Int]
      for (word <- str.split("\\s+")) {
        count += (word -> (count.getOrElse(word, 0) + 1))
      }
      count
    }

    println(wordCountTreeMap(str))

    // 9、在REPL中打印出所有Java系统属性的表格，需要有格式，如下：
    import scala.collection.JavaConversions.propertiesAsScalaMap
    val props: scala.collection.Map[String, String] = System.getProperties()
    for (item <- props) {
      println(item)
    }

    // 10、编写一个函数 minmax(values:Array[Int]), 返回数组中最小值和最大值的对偶
    def minmax(values: Array[Int]): (Int, Int) = {
      (values.min, values.max)
    }

    println(minmax(Array(1, 2, 34, 44)))


    // 11、编写一个函数indexes，给定字符串，产出一个包含所有字符下标的映射。
    // 举例来说：indexes(“Mississippi”)应返回一个映射，让’M’对应集{0}，‘i’对应集{1，4，7，10}，依次类推。使用字符到可变集的映射，注意下标的集应该是有序的。

    def indexes(str: String): Map[Char, SortedSet[Int]] = {
      var map = new HashMap[Char, SortedSet[Int]]()
      var i = 0
      str.foreach {
        c =>
          map.get(c) match {
            case Some(result) => {println(result) ;map(c) = result + i}
            case None => map += (c -> SortedSet {
              i
            })
          }
          i += 1
      }
      map
    }
    println(indexes("Mississippi"))
  }
}
